home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / seyon / SeScript.c < prev    next >
C/C++ Source or Header  |  1995-05-03  |  9KB  |  585 lines
  1.  
  2. /*
  3.  * This file is part of the Seyon, Copyright (c) 1992-1993 by Muhammad M.
  4.  * Saggaf. All rights reserved.
  5.  *
  6.  * See the file COPYING (1-COPYING) or the manual page seyon(1) for a full
  7.  * statement of rights and permissions for this program.
  8.  */
  9.  
  10. #include <time.h>
  11.  
  12. #include <X11/Intrinsic.h>
  13. #include <X11/StringDefs.h>
  14.  
  15. #include "seyon.h"
  16. #include "SeDecl.h"
  17.  
  18. #ifdef SUNOS_3
  19. #include <setjmp.h>
  20. #endif
  21.  
  22. #define    MAX_PATH    256
  23. #define    MAX_LINE    128
  24.  
  25. extern int      MdmTimedReadChar();
  26.  
  27. extern FILE    *tfp;
  28. extern char     scriptDirectory[REG_BUF];
  29.  
  30. static FILE    *cf;
  31. int             waitfor_time = 0,
  32.                 if_flag = 0,
  33.                 waitflag = 0;
  34. Boolean         tty_flag = True,
  35.                 echo_flag = False,
  36.                 captflag = True;
  37. jmp_buf         here;
  38.  
  39. void            k_debug(),
  40.                 k_echo(),
  41.                 k_flush(),
  42.                 k_hangup(),
  43.                 k_purge(),
  44.                 k_send_break(),
  45.                 k_shell(),
  46.                 k_waitfor(),
  47.                 k_when(),
  48.                 k_transmit(),
  49.                 k_pause(),
  50.                 k_exit(),
  51.                 k_quit(),
  52.                 k_if(),
  53.                 k_goto(),
  54.                 k_else(),
  55.                 k_endif(),
  56.                 k_redial(),
  57.                 k_dial(),
  58.                 s_set(),
  59.                 k_tty(),
  60.                 k_capture();
  61.  
  62. /* globals */
  63.  
  64. int             linkflag = 0;
  65.  
  66. static struct kw kw[] =
  67. {
  68.   {"debug", k_debug},
  69.   {"echo", k_echo},
  70.   {"flush", k_flush},
  71.   {"hangup", k_hangup},
  72.   {"purge", k_purge},
  73.   {"send_break", k_send_break},
  74.   {"shell", k_shell},
  75.   {"waitfor", k_waitfor},
  76.   {"when", k_when},
  77.   {"transmit", k_transmit},
  78.   {"pause", k_pause},
  79.   {"exit", k_exit},
  80.   {"if", k_if},
  81.   {"else", k_else},
  82.   {"endif", k_endif},
  83.   {"goto", k_goto},
  84.   {"dial", k_dial},
  85.   {"redial", k_redial},
  86.   {"quit", k_quit},
  87.   {"set", s_set},
  88.   {"capture", k_capture},
  89.   {"tty", k_tty},
  90.   {NULL, NULL}};
  91.  
  92. Boolean
  93. do_script(scriptFileName)
  94.      String         scriptFileName;
  95. {
  96.   char           *scriptDir,
  97.                   buf[REG_BUF];
  98.   FILE           *scriptFP;
  99.  
  100.   if (qres.scriptDirectory) scriptDir = qres.scriptDirectory;
  101.   else scriptDir = qres.defaultDirectory;
  102.   
  103.   strcpy(buf, scriptFileName);
  104.   if ((scriptFP = open_file(buf, scriptDir)) == NULL)
  105.     return False;
  106.   
  107.   exec_close_script(scriptFP);
  108.   return True;
  109. }
  110.  
  111. void
  112. exec_close_script(script_fp)
  113.      FILE           *script_fp;
  114. {
  115.   if_flag = 0;
  116.   echo_flag = False;
  117.   captflag = False;
  118.   tty_flag = True;
  119.   eof_flag = 0;
  120.  
  121.   if (linkflag == 2)
  122.     linkflag = 0;
  123.  
  124.   while (!eof_flag)
  125.     get_line(script_fp);
  126.  
  127.   fclose(script_fp);
  128.   if (captflag)
  129.     fclose(cf);
  130.  
  131.   eof_flag = 0;
  132.   lptr = strcpy(line, "");
  133.   k_when();
  134.  
  135.   linkflag = 0;
  136.  
  137.   return;
  138. }
  139.  
  140. static char     wf[MAX_LINE];
  141.  
  142. void
  143. get_line(script_fp)
  144.      FILE           *script_fp;
  145. {
  146.   int             i;
  147.  
  148.   getline(script_fp);
  149.  
  150.   if (eof_flag)
  151.     return;
  152.  
  153.   getword();
  154.  
  155.   if (echo_flag) {
  156.     if (strcmp(word, "transmit"))
  157.       show(line);
  158.     else
  159.       show("TRANSMIT...");
  160.   }
  161.  
  162.   if (word[0] == '\0')           /* Ignore blank lines */
  163.     return;
  164.   if (word[0] == '#')           /* Ignore comments */
  165.     return;
  166.  
  167.   if (word[strlen(word) - 1] == ':')    /* Ignore labels */
  168.     return;
  169.  
  170.   if (if_flag == -1) {
  171.     if (strcmp(word, "else") && strcmp(word, "endif"))
  172.       return;
  173.   }
  174.  
  175.   for (i = 0; kw[i].keyword != NULL; i++)
  176.     if (strcmp(kw[i].keyword, word) == 0) {
  177.       (*kw[i].rtn) (script_fp);
  178.       return;
  179.     }
  180.  
  181.   fprintf(tfp, "UNDEFINED COMMAND: \"%s\"\r\n", word);
  182.   eof_flag = 1;
  183.   return;
  184. }
  185.  
  186. struct _when {
  187.   String          expect;
  188.   String          send;
  189.   String          ptr;
  190. };
  191.  
  192. struct _when    when[MAX_ENT] =
  193. {
  194.   {NULL, NULL, NULL}};
  195.  
  196. void
  197. k_waitfor()
  198. {
  199.   long            t;
  200.   char           *ptr = wf, c;
  201.   struct _when   *whenPtr;
  202.  
  203.  
  204.   GETTEST_ARG("waitfor");
  205.   strcpy(wf, word);
  206.  
  207.   GET_ARG();
  208.  
  209.   for (whenPtr = when; whenPtr->expect; whenPtr++)
  210.     whenPtr->ptr = whenPtr->expect;
  211.  
  212.   if (word[0])
  213.     waitfor_time = atoi(word);
  214.   else
  215.     waitfor_time = 30;
  216.  
  217.   t = time(NULL) + waitfor_time;
  218.  
  219.   while (t != time(NULL) && !eof_flag) {
  220.     if (MdmTimedReadChar(&c, 1) < 0)
  221.       continue;
  222.  
  223.     if (tty_flag)
  224.       fputc(c, tfp);
  225.  
  226.     if (captflag)
  227.       fputc(c, cf);
  228.  
  229.     if ((char)c != *ptr)
  230.       ptr = wf;
  231.     else if (*++ptr == '\0') {
  232.       waitflag = 1;
  233.       return;
  234.     }
  235.  
  236.     for (whenPtr = when; whenPtr->expect; whenPtr++) {
  237.       if ((char)c != *(whenPtr->ptr))
  238.         whenPtr->ptr = whenPtr->expect;
  239.       else if (*++(whenPtr->ptr) == '\0')
  240.         MdmPutString(whenPtr->send);
  241.     }
  242.  
  243.   }
  244.  
  245.   waitflag = 0;
  246. }
  247.  
  248. void
  249. k_when()
  250. {
  251.   struct _when   *whenPtr;
  252.  
  253.   GET_ARG();
  254.   if (word[0] == '\0') {
  255.     for (whenPtr = when; whenPtr->expect; whenPtr++) {
  256.       XtFree(whenPtr->expect);
  257.       XtFree(whenPtr->send);
  258.     }
  259.     when[0].expect = NULL;
  260.     return;
  261.   }
  262.  
  263.   for (whenPtr = when; whenPtr->expect; whenPtr++);
  264.   whenPtr->expect = XtNewString(word);
  265.   (whenPtr + 1)->expect = NULL;
  266.  
  267.   GETTEST_ARG("when");
  268.   whenPtr->send = XtNewString(word);
  269. }
  270.  
  271. void
  272. k_transmit()
  273. {
  274.  
  275.   getword();
  276.   if (eof_flag)
  277.     return;
  278.  
  279.   if (word[0] == '\0') {
  280.     fprintf(tfp, "No argument to TRANSMIT command\r\n");
  281.     eof_flag = 1;
  282.     return;
  283.   }
  284.  
  285.   MdmPutString(word);
  286. }
  287.  
  288. void
  289. k_pause()
  290. {
  291.   int             pause_time;
  292.  
  293.   getword();
  294.   if (eof_flag)
  295.     return;
  296.  
  297.   if (word[0] == '\0')
  298.     pause_time = 5;
  299.   else
  300.     pause_time = atoi(word);
  301.  
  302.   sleep(pause_time);
  303. }
  304.  
  305. void
  306. k_quit()
  307. {
  308.   write_child_info(child_pipe, EXIT_PROGRAM, "");
  309.   k_exit();
  310. }
  311.  
  312. void
  313. k_exit()
  314. {
  315.   eof_flag = 1;
  316. }
  317.  
  318. static char     label[WBSIZE];
  319.  
  320. void
  321. k_goto(script_fp)
  322.      FILE           *script_fp;
  323. {
  324.   int             found = 0,
  325.                   i;
  326.  
  327.   getword();
  328.   if (word[0] == '\0') {
  329.     fprintf(tfp, "No argument for GOTO: %s\r\n", line);
  330.     eof_flag++;
  331.     return;
  332.   }
  333.  
  334.   strcpy(label, word);
  335.  
  336.   rewind(script_fp);
  337.   while (!found) {
  338.     getline(script_fp);
  339.     if (eof_flag)
  340.       break;
  341.  
  342.     getword();
  343.     if (word[0] == '\0' || word[0] == '#')
  344.       continue;
  345.  
  346.     if (word[i = (strlen(word) - 1)] != ':')
  347.       continue;
  348.  
  349.     word[i] = '\0';
  350.  
  351.     found = (strcmp(word, label) == 0);
  352.   }
  353.  
  354.   if (eof_flag) {
  355.     fprintf(tfp, "Label %s not found\r\n", label);
  356.     eof_flag++;
  357.     return;
  358.   }
  359.  
  360.   if_flag = 0;               /* reset IF flag */
  361. }
  362.  
  363. static          if_negate = 0;
  364.  
  365. static int
  366. if_test(cond)
  367.      int             cond;
  368. {
  369.   if (if_negate)
  370.     cond = !cond;
  371.  
  372.   if (cond)
  373.     return 1;
  374.   else
  375.     return -1;
  376. }
  377.  
  378. void
  379. k_if()
  380. {
  381.   char           *ptr;
  382.  
  383.   if (if_flag) {
  384.     fprintf(tfp, "Nested IF statements not allowed\r\n");
  385.     eof_flag++;
  386.     return;
  387.   }
  388.  
  389.   if_negate = 0;
  390.   getword();
  391.   if (word[0] == '\0') {
  392.     fprintf(tfp, "No condition on IF statement\r\n");
  393.     eof_flag++;
  394.     return;
  395.   }
  396.  
  397.   if (strcmp(word, "not") == 0) {
  398.     if_negate = 1;
  399.     getword();
  400.     if (word[0] == '\0') {
  401.       fprintf(tfp, "No condition on IF statement\r\n");
  402.       eof_flag++;
  403.       return;
  404.     }
  405.   }
  406.  
  407.   if (word[0] == '!') {
  408.     if_negate = 1;
  409.     ptr = word + 1;
  410.   }
  411.   else
  412.     ptr = word;
  413.  
  414.   if (strcmp(ptr, "waitfor") == 0) {
  415.     if_flag = if_test(waitflag);
  416.     return;
  417.   }
  418.  
  419.   if (strcmp(ptr, "linked") == 0) {
  420.     if_flag = if_test(linkflag);
  421.     return;
  422.   }
  423.  
  424.   fprintf(tfp, "Undefined IF condition %s\r\n", ptr);
  425.   eof_flag++;
  426.   return;
  427. }
  428.  
  429. void
  430. k_else()
  431. {
  432.   if (!if_flag) {
  433.     fprintf(tfp, "ELSE not within IF\r\n");
  434.     eof_flag++;
  435.     return;
  436.   }
  437.  
  438.   if_flag = -if_flag;
  439. }
  440.  
  441. void
  442. k_endif()
  443. {
  444.   if (!if_flag) {
  445.     fprintf(tfp, "ENDIF not wihtin IF\r\n");
  446.     eof_flag++;
  447.     return;
  448.   }
  449.  
  450.   if_flag = 0;
  451. }
  452.  
  453. void
  454. k_dial()
  455. {
  456.   getword();
  457.  
  458.   if (word[0] == '\0') {
  459.     fprintf(tfp, "DIAL command must have an argument\r\n");
  460.     eof_flag++;
  461.     return;
  462.   }
  463.  
  464.   dial(word);
  465. }
  466.  
  467. void
  468. k_redial()
  469. {
  470.   if (redial(NULL)) {
  471.     eof_flag++;
  472.     return;
  473.   }
  474. }
  475.  
  476. void
  477. k_debug()
  478. {
  479.   set_onoff(&echo_flag);
  480.   return;
  481. }
  482.  
  483. void
  484. k_echo()
  485. {
  486.   GET_ARG();
  487.   show(word);
  488. }
  489.  
  490. void
  491. k_flush()
  492. {
  493.   MdmIFlush();
  494. }
  495.  
  496. void
  497. k_hangup()
  498. {
  499.   MdmHangup();
  500. }
  501.  
  502. void
  503. k_purge()
  504. {
  505.   MdmPurge();
  506. }
  507.  
  508. void
  509. k_send_break()
  510. {
  511.   send_break();
  512. }
  513.  
  514. void
  515. k_shell()
  516. {
  517.   GETTEST_ARG("shell");
  518.   ExecShellCommand(word, 0);
  519. }
  520.  
  521. void
  522. k_capture()
  523. {
  524.   Boolean         val = captflag;
  525.  
  526.   set_onoff(&captflag);
  527.   if (eof_flag)
  528.     return;
  529.  
  530.   if (val == captflag)
  531.     return;
  532.  
  533.   if (captflag == False)
  534.     fclose(cf);
  535.   else {
  536.     if ((cf = fopen(captureFile, "a")) == NULL) {
  537.       fprintf(tfp, "Cannot open capture file %s\r\n", captureFile);
  538.       eof_flag++;
  539.       return;
  540.     }
  541.   }
  542. }
  543.  
  544. void
  545. k_tty()
  546. {
  547.   set_onoff(&tty_flag);
  548.   return;
  549. }
  550.  
  551. /*
  552.  * Dial a phone number, using proper format and delay.
  553.  */
  554.  
  555. static char    *last_nbr = NULL;
  556.  
  557. void
  558. dial(s)
  559.      char           *s;
  560. {
  561.   if (last_nbr)
  562.     XtFree(last_nbr);
  563.  
  564.   last_nbr = XtNewString(s);
  565.  
  566.   mprintf("\r%s %s%s", qres.dialPrefix, s, qres.dialSuffix);
  567. }
  568.  
  569. int
  570. redial(last_nbr)
  571.      char           *last_nbr;
  572. {
  573.   char           *s;
  574.  
  575.   if (last_nbr == NULL) {
  576.     show("REDIAL FAILURE");
  577.     return 1;
  578.   }
  579.  
  580.   s = XtNewString(last_nbr);
  581.   dial(s);
  582.   XtFree(s);
  583.   return 0;
  584. }
  585.